This application contains Microfiche Appendix A consisting of seven (7) slides and 590 frames.
The invention relates to a method of manipulating and controlling information within a large scale network of computing and storage devices through the use of a common command format and centralized storage management across the network.
Modern computers and information storage devices (referred to here as simply xe2x80x9cinformation processing devicesxe2x80x9d) are manufactured worldwide by a wide range of companies (e.g., IBM, Compaq, Apple, etc.). A wide variety of such devices is currently manufactured.
The broad range of computers stretches from small computers designed to perform specialized tasks (e.g., operate a microwave or an ATM machine) to large, high speed, parallel processing computers such as are utilized in weather forecasting and other computing intensive applications (e.g., finite element analysis and aerodynamic modeling) and includes many computing devices between (household or business PCs).
There is also a wide variety of information storage devices including hard disks commonly used in personal computers (that may store millions or billions of bytes), CD-ROM drives, and large redundant arrays of inexpensive disks (RAID) servers that may store several trillion bytes. Of course, it is to be understood that the information stored in a byte is limited only to that information that may be represented in a binary format, i.e., the stored information may be data, a picture, a sound, a computer program, multi-media, etc.
Commonly, such a device is controlled through a command set referred to as an xe2x80x9cinterface.xe2x80x9d Generally speaking, an interface is a high-level set of commands which an information processing device is capable of recognizing and to which it can react in some manner.
For example, as shown in FIG. 1A, a storage device may be instructed to delete a particular file stored on it by sending it a command such as xe2x80x9cDELETE, file_name.xe2x80x9d In this example, xe2x80x9cfile_namexe2x80x9d is the name of the file or other information to be deleted.
Of course, those of ordinary skill in the art will appreciate that the foregoing example is a hypothetical example intended for purposes of illustration only. Actual interface commands are normally transmitted in digital form and may contain or require other additional or different information in a different format.
An information processing device may be controlled by, or control, other such devices by receiving or transmitting interface commands. Thus, a storage device may be controlled through an interface command (such as the one shown above) issued by a computer.
In addition, as shown in FIG. 1B and described in more detail below, a computer may control another computer by issuing an interface command.
Typically, interface commands to which a particular information processing device responds are related to the underlying function of the particular device. For example, a storage device (a hard disk) may respond to commands such as: DELETE, COPY, STORE, RETRIEVE, MOVE, etc. On the other hand, a computer may respond to commands such as: DISPLAY, TRANSMIT, PRINT, etc. Again, those of ordinary skill in the art will appreciate that the foregoing examples are illustrative only and actual interface commands may be different or require additional information.
Interface commands to which an information processing device responds are typically selected by manufacturers or interface designers. The selection of a particular command may or may not be dictated by any particular constraints. Thus, rather than choosing the command xe2x80x9cDELETExe2x80x9d, shown in the above example, a manufacturer or interface designer may select xe2x80x9cREMOVExe2x80x9d or xe2x80x9c42xe2x80x9d or any other name for the command.
Because there are a large number of companies and individuals involved in the manufacture of information processing devices world-wide, as well as a large number of such devices, there are many different interface command sets. The command set that controls a particular device may be unique to that device.
Although not necessarily a requirement, interface commands are typically issued by computer programs. Computer programs are also referred to as xe2x80x9csoftware,xe2x80x9d xe2x80x9ccode,xe2x80x9d or xe2x80x9capplications.xe2x80x9d A developer or other person will write a computer program that issues a series of interface commands when run on a separate computer.
For example, as shown in FIG. 2, suppose that a developer writes a computer program to print a file (e.g., a letter). When run, the computer program issues an interface command to a disk drive to retrieve the file and another to an attached printer to print it.
Information processing devices commonly accept interface commands through software/hardware referred to as an applications programming interface (API). Normally, an API is implemented through software that accepts interface commands in a specialized format and then directly or indirectly causes the device in question to perform the operations or further process the command.
For example, controller software for a disk drive, e.g., basic input/output system (BIOS) software, may implement an API by accepting an interface command such as xe2x80x9cWRITE, file_namexe2x80x9d and then passing the command directly to the disk drive hardware in a format suitable for actually operating the hardware. The controller software may also perform other tasks (e.g., locate free space on the disk, move the drive head to the proper location, copy the file_name information to local storage on the disk drive, and then finally write the information to the disk).
Thus, as shown in FIG. 3, a developer of an application can write instructions (e.g., xe2x80x9cdisk_drive(WRITE, file_name);xe2x80x9d) that will be interpreted by other, API-implementing software. This is sometimes referred to as xe2x80x9cwriting to the API,xe2x80x9d where the term xe2x80x9cAPIxe2x80x9d is used as a colloquialism for software that implements the API.
In order to facilitate incorporation into existing systems and future programs, API""s are commonly written specifically for information processing devices comprising specific combinations of software and hardware that are unique to that device and may or may not be common to any other device.
Computer Networks
As shown in FIG. 4, it is well known that computers may be connected together in a network or networks so that the computers may communicate and/or share resources such as storage. Computers connected in a network may be located close together, (e.g., a local area network (LAN) in an office) or somewhat farther apart on a wide area network (WAN).
In addition, computers may be connected to the world-wide network of computers referred to as the Internet. One portion of the Internet is referred to as the World Wide Web and is a network of computers complying with a graphical interface standard similar to the widely known Windows or Macintosh interfaces. Java is a programming language/script (Java applet) developed by Sun Microsystems, Inc. and incorporated or supported by other manufacturers. Java is designed to be a platform independent programming language.
Also as shown in FIG. 4, when operating across a network, computers may share resources such as storage. Indeed, shared storage (implying access to shared data) is one of the primary motivations for networking computers.
Shared storage reduces costs associated with computing because a single copy of the desired information may be accessed by a large number of computers. That in turn reduces some of the costs and other difficulties associated with storing and updating multiple copies of a particular piece of information.
Information processing devices which handle requests for information or activity from other devices are referred to as xe2x80x9cservers.xe2x80x9d Requesting devices (e.g., computers operated by end users) are referred to as xe2x80x9cclients.xe2x80x9d Both the term xe2x80x9cserverxe2x80x9d and xe2x80x9cclientxe2x80x9d focus on the operations being performed. Thus, a single computer may act as a server for some operations and a client for others. One or more clients and one or more servers together comprise a xe2x80x9cclient/serverxe2x80x9d network.
As illustrated in FIGS. 5 and 6, advances in network architectures over the last several decades have reduced the need for computers in a network to be connected to each other, i.e., there does not need to be a direct connection between each pair of computers on a network. Rather, interface commands or information intended for a particular information processing device may be passed along by several intervening computers before arriving at their intended destination. Specialized computers designed to manage interface commands and direct them to the proper device are referred to as xe2x80x9croutersxe2x80x9d or xe2x80x9cswitches.xe2x80x9d FIG. 6.
Interface Problems Across a Network
As shown in FIG. 7, a large number of information processing devices connected to a network will often require a large number of interface command sets and APIs to control. Thus, a client or end user wishing to access a particular piece of information stored on a device located somewhere on a network may need to know the particular interface command set and API of that device, and potentially of all the intervening devices.
As shown in FIG. 8, in the past, network software (e.g., Novell, Banyan, Windows NT, UNIX, etc.) executing on a network server has been used to insulate clients (end users) at least somewhat from the profusion of interface command sets. Network software typically does so by limiting clients to a series of network-supported operations. The network software controls the entire network; it interacts with and issues interface commands to connected devices through APIs designed for that network (strictly speaking, through software that implements the APIs). For example, a client in such a network may issue a request to print, possibly in a network specific format. The network software then translates the request into a format suitable for passage to an API written specifically for the combination of the particular network software and the particular information processing device; the request is then serviced.
The need to develop an API for each network software/device combination (of which there are typically a large number) and the translation of interface commands among and through various APIs is a limiting factor in the further integration and efficient operation of large scale networks of computing and storage devices.
Storage Problems Across Networks
Referring to FIG. 9, a further difficulty heretofore encountered in large scale networks relates to the manipulation and storage of data across the network. In order to reduce the total amount of work required by the network software and transmission of data across the network (often referred to as network xe2x80x9cloadxe2x80x9d) and the attendant slow response times, prior art computer networks and software have not attempted to manage storage across the network in a centralized manner. This decentralized method of operating a network is often referred to as a xe2x80x9cdistributedxe2x80x9d system and storage management is performed at the local level.
Thus, on such a network there is no centralized list of files or locations. Clients must either know the storage location of a particular piece of information or must request a list of stored information from each storage device (often referred to as xe2x80x9cpollingxe2x80x9d).
Furthermore, in such a system the same item of information may be unwittingly stored in multiple locations thereby wasting valuable storage space.
Because distributed storage management systems require clients to know information locations or poll the storage devices, movement of information from one storage device to another in such a network may require clients to poll all the storage devices to retrieve information simply because the storage address has changed. In large scale prior art networks currently in the field, the lack of centralized storage management is a continuing source of expense and end user dissatisfaction.
As illustrated in FIG. 10, a further difficulty experienced in distributed storage management systems relates to changes (additions, deletions, modifications, or simple movement) of the stored information. This is referred to as the general problem of consistency control, often referred to as xe2x80x9ccache consistency controlxe2x80x9d in multi-tasking operating systems. In distributed storage management systems, information in use by clients may be modified by other clients thereby resulting in errors in the first client""s operations. For example, one client may be in the process of retrieving a spreadsheet with totals while another client may update the same spreadsheet thereby altering the totals.
Many solutions to the general problem of consistency control in the small scale environment of multi-tasking operating systems and smaller networks are known in the art. Consistency control is nevertherless a major problem in large scale networks because of the lack of a centralized storage management system.
A method in accordance with the invention utilizes a client/server network of information processing devices that includes a centralized database of storage locations; communication among the networked devices is by means of a generalized command set. The centralized database of storage locations maintains a list of information locations and other information associated with a particular piece of information and coordinates access to the data. Devices connected to the network communicate by issuing and receiving generalized commands to access, manage and maintain content.